home *** CD-ROM | disk | FTP | other *** search
/ Your Mobile: Alcatel / Alcatel 2005.iso / Collections / JpegView / setup.exe / JpegDecoder.class (.txt) < prev    next >
Encoding:
Java Class File  |  2001-10-15  |  15.6 KB  |  1,021 lines
  1. import java.io.InputStream;
  2. import javax.microedition.lcdui.Graphics;
  3. import javax.microedition.lcdui.Image;
  4.  
  5. class JpegDecoder {
  6.    // $FF: renamed from: ├å int
  7.    int field_0;
  8.    // $FF: renamed from: ├ç int
  9.    int field_1;
  10.    // $FF: renamed from: ├ê int
  11.    int field_2;
  12.    // $FF: renamed from: ├ë int
  13.    int field_3;
  14.    // $FF: renamed from: ├è int
  15.    int field_4;
  16.    // $FF: renamed from: qt int[][]
  17.    int[][] field_5 = new int[4][64];
  18.    // $FF: renamed from: ├ï COMPONENT[]
  19.    COMPONENT[] field_6 = new COMPONENT[6];
  20.    // $FF: renamed from: ├î HuffmanTable[]
  21.    HuffmanTable[] field_7 = new HuffmanTable[4];
  22.    // $FF: renamed from: ├ì HuffmanTable[]
  23.    HuffmanTable[] field_8 = new HuffmanTable[4];
  24.    // $FF: renamed from: ├Ä int
  25.    int field_9;
  26.    // $FF: renamed from: ├Å int
  27.    int field_10;
  28.    // $FF: renamed from: ├É int
  29.    int field_11;
  30.    // $FF: renamed from: ├æ int
  31.    int field_12;
  32.    // $FF: renamed from: ├Æ byte[][]
  33.    byte[][] field_13 = new byte[5][];
  34.    // $FF: renamed from: ri int
  35.    int field_14;
  36.    // $FF: renamed from: ├ô int[]
  37.    int[] field_15 = new int[]{0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63};
  38.    // $FF: renamed from: ├ö javax.microedition.lcdui.Image
  39.    Image field_16;
  40.    // $FF: renamed from: ├ò boolean
  41.    boolean field_17 = false;
  42.    // $FF: renamed from: ├û int
  43.    int field_18 = 0;
  44.    public int poolsize;
  45.    // $FF: renamed from: ├ÿ int
  46.    int field_19;
  47.    // $FF: renamed from: ├Ö byte[]
  48.    byte[] field_20;
  49.    // $FF: renamed from: ├Ü int[]
  50.    int[] field_21 = new int[64];
  51.  
  52.    public JpegDecoder(byte[] var1) {
  53.       this.field_20 = var1;
  54.       this.poolsize = this.field_20.length;
  55.       this.field_19 = 0;
  56.    }
  57.  
  58.    public JpegDecoder(InputStream var1) {
  59.       byte[][] var2 = new byte[64][1];
  60.       int var3 = 0;
  61.       int var4 = 0;
  62.  
  63.       while(true) {
  64.          var2[var3] = new byte[1024];
  65.  
  66.          try {
  67.             var4 = var1.read(var2[var3]);
  68.          } catch (Exception var8) {
  69.             var4 = 0;
  70.          }
  71.  
  72.          this.poolsize += var4;
  73.          if (var4 != 1024) {
  74.             this.field_20 = new byte[this.poolsize];
  75.             this.field_19 = 0;
  76.             int var5 = 0;
  77.             int var6 = 0;
  78.  
  79.             for(int var7 = 0; var7 <= var3; ++var7) {
  80.                if (var7 == var3) {
  81.                   var6 = var4;
  82.                } else {
  83.                   var6 = 1024;
  84.                }
  85.  
  86.                System.arraycopy(var2[var7], 0, this.field_20, var5, var6);
  87.                var5 += var6;
  88.             }
  89.  
  90.             return;
  91.          }
  92.  
  93.          ++var3;
  94.       }
  95.    }
  96.  
  97.    public void setColorImage() {
  98.       this.field_17 = false;
  99.    }
  100.  
  101.    public void setGrayScaleImage() {
  102.       this.field_17 = true;
  103.    }
  104.  
  105.    public void setBright(int var1) {
  106.       this.field_18 = var1;
  107.    }
  108.  
  109.    public Image decodeImage() {
  110.       this.field_16 = null;
  111.       this.method_0();
  112.       return this.field_16;
  113.    }
  114.  
  115.    // $FF: renamed from: ├å () void
  116.    void method_0() {
  117.       for(int var1 = 0; var1 < 6; ++var1) {
  118.          this.field_6[var1] = new COMPONENT();
  119.       }
  120.  
  121.       for(int var2 = 0; var2 < 4; ++var2) {
  122.          this.field_7[var2] = new HuffmanTable();
  123.          this.field_8[var2] = new HuffmanTable();
  124.       }
  125.  
  126.       if (this.method_13() == 65496) {
  127.          while(true) {
  128.             int var3 = this.method_12();
  129.             int var4 = this.method_12();
  130.             if (var3 != 255) {
  131.                return;
  132.             }
  133.  
  134.             while(var4 == 255) {
  135.                var4 = this.method_12();
  136.             }
  137.  
  138.             switch (var4) {
  139.                case 1:
  140.                case 208:
  141.                case 209:
  142.                case 210:
  143.                case 211:
  144.                case 212:
  145.                case 213:
  146.                case 214:
  147.                case 215:
  148.                   break;
  149.                case 192:
  150.                   if (!this.method_2()) {
  151.                      return;
  152.                   }
  153.                   break;
  154.                case 193:
  155.                case 194:
  156.                case 195:
  157.                case 197:
  158.                case 198:
  159.                case 199:
  160.                case 200:
  161.                case 201:
  162.                case 202:
  163.                case 203:
  164.                case 204:
  165.                case 205:
  166.                case 206:
  167.                case 207:
  168.                   return;
  169.                case 196:
  170.                   if (!this.method_4()) {
  171.                      return;
  172.                   }
  173.                   break;
  174.                case 217:
  175.                   this.method_10();
  176.                   return;
  177.                case 218:
  178.                   if (!this.method_5()) {
  179.                      return;
  180.                   }
  181.                   break;
  182.                case 219:
  183.                   if (!this.method_1()) {
  184.                      return;
  185.                   }
  186.                   break;
  187.                case 221:
  188.                   if (!this.method_3()) {
  189.                      return;
  190.                   }
  191.                   break;
  192.                default:
  193.                   int var5 = this.method_13() - 2;
  194.                   this.method_11(var5);
  195.             }
  196.          }
  197.       }
  198.    }
  199.  
  200.    // $FF: renamed from: ├ç () boolean
  201.    boolean method_1() {
  202.       int var4;
  203.       for(var4 = this.method_13() - 2; var4 > 0; var4 -= 64) {
  204.          int var1 = this.method_12();
  205.          --var4;
  206.          int var3 = var1 & 15;
  207.          int var2 = var1 >> 4;
  208.          if (var2 != 0 || var3 >= 4) {
  209.             return false;
  210.          }
  211.  
  212.          for(int var5 = 0; var5 < 64; ++var5) {
  213.             this.field_5[var3][var5] = this.method_12();
  214.          }
  215.       }
  216.  
  217.       if (var4 != 0) {
  218.          return false;
  219.       } else {
  220.          return true;
  221.       }
  222.    }
  223.  
  224.    // $FF: renamed from: ├ê () boolean
  225.    boolean method_2() {
  226.       int var4 = this.method_13() - 2;
  227.       if (this.method_12() != 8) {
  228.          return false;
  229.       } else {
  230.          this.field_1 = this.method_13();
  231.          this.field_0 = this.method_13();
  232.          if (this.field_1 != 0 && this.field_0 != 0) {
  233.             this.field_4 = this.method_12();
  234.  
  235.             for(int var5 = 0; var5 < this.field_4; ++var5) {
  236.                int var1 = this.method_12();
  237.                if (var1 > 5) {
  238.                   return false;
  239.                }
  240.  
  241.                int var2 = this.method_12();
  242.                int var3 = this.method_12();
  243.                this.field_6[var1].h = var2 >> 4;
  244.                this.field_6[var1].v = var2 & 15;
  245.                this.field_6[var1].├Ç = var3;
  246.                if (this.field_6[var1].h == 0 || this.field_6[var1].v == 0) {
  247.                   return false;
  248.                }
  249.  
  250.                if (this.field_9 < this.field_6[var1].h) {
  251.                   this.field_9 = this.field_6[var1].h;
  252.                }
  253.  
  254.                if (this.field_10 < this.field_6[var1].v) {
  255.                   this.field_10 = this.field_6[var1].v;
  256.                }
  257.             }
  258.  
  259.             this.field_11 = (this.field_0 + this.field_9 * 8 - 1) / (this.field_9 * 8);
  260.             this.field_12 = (this.field_1 + this.field_10 * 8 - 1) / (this.field_10 * 8);
  261.             this.field_2 = this.field_11 * this.field_9 * 8;
  262.             this.field_3 = this.field_12 * this.field_10 * 8;
  263.  
  264.             for(int var6 = 0; var6 < this.field_4; ++var6) {
  265.                try {
  266.                   this.field_13[var6] = new byte[this.field_2 * this.field_3];
  267.                } catch (Exception var8) {
  268.                   return false;
  269.                }
  270.             }
  271.  
  272.             return true;
  273.          } else {
  274.             return false;
  275.          }
  276.       }
  277.    }
  278.  
  279.    // $FF: renamed from: ├ë () boolean
  280.    boolean method_3() {
  281.       if (this.method_13() != 4) {
  282.          return false;
  283.       } else {
  284.          this.field_14 = this.method_13();
  285.          return true;
  286.       }
  287.    }
  288.  
  289.    // $FF: renamed from: ├è () boolean
  290.    boolean method_4() {
  291.       int[] var5 = new int[16];
  292.       int var6 = this.method_13() - 2;
  293.  
  294.       while(var6 > 0) {
  295.          int var1 = this.method_12();
  296.          --var6;
  297.          int var2 = var1 & 15;
  298.          int var3 = var1 >> 4 & 1;
  299.          if (var2 >= 2) {
  300.             return false;
  301.          }
  302.  
  303.          HuffmanTable var4;
  304.          if (var3 == 0) {
  305.             var4 = this.field_7[var2];
  306.          } else {
  307.             var4 = this.field_8[var2];
  308.          }
  309.  
  310.          for(int var7 = 0; var7 < 16; ++var7) {
  311.             var5[var7] = this.method_12();
  312.          }
  313.  
  314.          var6 -= 16;
  315.  
  316.          for(int var8 = 0; var8 < 16; ++var8) {
  317.             for(int var9 = 0; var9 < var5[var8]; ++var9) {
  318.                var1 = this.method_12();
  319.                --var6;
  320.                var4.addNode(var8 + 1, var1);
  321.             }
  322.          }
  323.       }
  324.  
  325.       return true;
  326.    }
  327.  
  328.    // $FF: renamed from: ├ï () boolean
  329.    boolean method_5() {
  330.       int[] var2 = new int[4];
  331.       int[] var3 = new int[4];
  332.       int[] var4 = new int[4];
  333.       int[] var5 = new int[4];
  334.       int var6 = this.method_13() - 2;
  335.       int var7 = this.method_12();
  336.       if (var7 >= 1 && var7 <= 4) {
  337.          int var1 = var7;
  338.  
  339.          for(int var8 = 0; var8 < var1; ++var8) {
  340.             var7 = this.method_12();
  341.             if (var7 > 5) {
  342.                return false;
  343.             }
  344.  
  345.             var2[var8] = var7;
  346.             var7 = this.method_12();
  347.             var3[var8] = var7 >> 4;
  348.             var4[var8] = var7 & 15;
  349.             if (var3[var8] > 4 || var4[var8] > 4) {
  350.                return false;
  351.             }
  352.          }
  353.  
  354.          this.method_11(3);
  355.          int[] var9 = new int[4];
  356.          int[] var10 = new int[100];
  357.          int[] var11 = new int[64];
  358.          int[] var12 = new int[140];
  359.          int var13 = 0;
  360.          int var14 = 0;
  361.          int var15 = 0;
  362.          boolean var16 = false;
  363.          int var17 = 0;
  364.          DECODE_PARAM var18 = new DECODE_PARAM();
  365.          boolean var19 = false;
  366.  
  367.          for(int var21 = 0; var21 < 4; ++var21) {
  368.             var5[var21] = 0;
  369.             var9[var21] = 0;
  370.          }
  371.  
  372.          var18.├ü = var12;
  373.          boolean var22 = false;
  374.  
  375.          label401:
  376.          while(true) {
  377.             int var23 = 0;
  378.  
  379.             label367:
  380.             while(true) {
  381.                if (var23 >= var1) {
  382.                   continue label401;
  383.                }
  384.  
  385.                HuffmanTable var25 = this.field_7[var3[var23]];
  386.                HuffmanTable var24 = this.field_8[var4[var23]];
  387.                int var26 = var2[var23];
  388.  
  389.                for(int var27 = 0; var27 < this.field_6[var26].h * this.field_6[var26].v; ++var27) {
  390.                   int var20 = 0;
  391.  
  392.                   while(var20 < 64) {
  393.                      if (var13 <= 30 && !var16) {
  394.                         for(int var28 = 0; var28 < var13; ++var28) {
  395.                            var12[var28] = var12[var15 + var28];
  396.                         }
  397.  
  398.                         var15 = 0;
  399.                         int var29;
  400.                         if (this.poolsize - this.field_19 > 100) {
  401.                            var29 = 100;
  402.                         } else {
  403.                            var29 = this.poolsize - this.field_19;
  404.                         }
  405.  
  406.                         for(int var30 = 0; var30 < var29; ++var30) {
  407.                            var12[var13 + var30] = this.method_12();
  408.                         }
  409.  
  410.                         var13 += var29;
  411.                         if (this.field_19 == this.poolsize) {
  412.                            var16 = true;
  413.                         }
  414.                      }
  415.  
  416.                      var18.├é = var15;
  417.                      var18.├â = var14;
  418.                      var18.├ä = var13;
  419.                      if (var20 == 0) {
  420.                         var19 = var25.deCode(var18);
  421.                         var17 = HuffmanTable.deCode_code;
  422.                      } else {
  423.                         var19 = var24.deCode(var18);
  424.                         var17 = HuffmanTable.deCode_code;
  425.                      }
  426.  
  427.                      var14 = var18.├â;
  428.                      var15 = var18.├é;
  429.                      var13 = var18.├ä;
  430.                      var14 %= 8;
  431.                      if (var13 <= 0) {
  432.                         return false;
  433.                      }
  434.  
  435.                      if (!var19) {
  436.                         break label367;
  437.                      }
  438.  
  439.                      int[] var32 = new int[4];
  440.                      if (var20 == 0) {
  441.                         int var52;
  442.                         if (var17 == 0) {
  443.                            var52 = 0;
  444.                         } else {
  445.                            int var58 = var17;
  446.                            int var60 = 0;
  447.                            int var57 = var14;
  448.                            if (var14 == 0) {
  449.                               if (var12[var15] != 255) {
  450.                                  if (var12[var15] == 0 && var12[var15 - 1] == 255) {
  451.                                     ++var15;
  452.                                     --var13;
  453.                                     if (var12[var15] == 255) {
  454.                                        while(var12[var15 + 1] == 255) {
  455.                                           ++var15;
  456.                                           --var13;
  457.                                        }
  458.  
  459.                                        if (var12[var15 + 1] != 0) {
  460.                                           break label367;
  461.                                        }
  462.                                     }
  463.                                  }
  464.                               } else {
  465.                                  while(var12[var15 + 1] == 255) {
  466.                                     ++var15;
  467.                                     --var13;
  468.                                  }
  469.  
  470.                                  if (var12[var15 + 1] != 0) {
  471.                                     break label367;
  472.                                  }
  473.                               }
  474.                            }
  475.  
  476.                            while(var58 > 0 && var60 < 4) {
  477.                               int var59 = 8 - var14;
  478.                               var32[var60] = var12[var15];
  479.                               if (var58 >= var59) {
  480.                                  ++var15;
  481.                                  var14 = 0;
  482.                                  --var13;
  483.                               } else {
  484.                                  var14 += var58;
  485.                               }
  486.  
  487.                               var58 -= var59;
  488.                               ++var60;
  489.                               if (var14 == 0) {
  490.                                  if (var12[var15] == 255) {
  491.                                     while(var12[var15 + 1] == 255) {
  492.                                        ++var15;
  493.                                        --var13;
  494.                                     }
  495.  
  496.                                     if (var12[var15 + 1] != 0) {
  497.                                        break label367;
  498.                                     }
  499.                                  } else if (var12[var15] == 0 && var12[var15 - 1] == 255) {
  500.                                     ++var15;
  501.                                     --var13;
  502.                                     if (var12[var15] == 255) {
  503.                                        while(var12[var15 + 1] == 255) {
  504.                                           ++var15;
  505.                                           --var13;
  506.                                        }
  507.  
  508.                                        if (var12[var15 + 1] != 0) {
  509.                                           break label367;
  510.                                        }
  511.                                     }
  512.                                  }
  513.                               }
  514.                            }
  515.  
  516.                            var52 = ((var32[0] & 255) << 24) + ((var32[1] & 255) << 16) + ((var32[2] & 255) << 8) + (var32[3] & 255);
  517.                            var52 <<= var57;
  518.                            if (var52 > 0) {
  519.                               var52 = 0 - (~var52 >>> 32 - var17);
  520.                            } else {
  521.                               var52 >>>= 32 - var17;
  522.                            }
  523.                         }
  524.  
  525.                         var9[var23] += var52;
  526.                         var10[0] = var9[var23];
  527.                         ++var20;
  528.                      } else if (var17 == 0) {
  529.                         while(var20 < 64) {
  530.                            var10[var20] = 0;
  531.                            ++var20;
  532.                         }
  533.                      } else if (var17 == 240) {
  534.                         for(int var61 = 0; var61 < 16; ++var61) {
  535.                            var10[var20] = 0;
  536.                            ++var20;
  537.                         }
  538.                      } else {
  539.                         int var54 = var17 >> 4;
  540.                         int var56 = var17 & 15;
  541.  
  542.                         for(int var36 = 0; var36 < var54; ++var36) {
  543.                            var10[var20] = 0;
  544.                            ++var20;
  545.                         }
  546.  
  547.                         if (var56 != 0) {
  548.                            int var33 = var56;
  549.                            int var35 = 0;
  550.                            int var31 = var14;
  551.                            if (var14 == 0) {
  552.                               if (var12[var15] != 255) {
  553.                                  if (var12[var15] == 0 && var12[var15 - 1] == 255) {
  554.                                     ++var15;
  555.                                     --var13;
  556.                                     if (var12[var15] == 255) {
  557.                                        while(var12[var15 + 1] == 255) {
  558.                                           ++var15;
  559.                                           --var13;
  560.                                        }
  561.  
  562.                                        if (var12[var15 + 1] != 0) {
  563.                                           break label367;
  564.                                        }
  565.                                     }
  566.                                  }
  567.                               } else {
  568.                                  while(var12[var15 + 1] == 255) {
  569.                                     ++var15;
  570.                                     --var13;
  571.                                  }
  572.  
  573.                                  if (var12[var15 + 1] != 0) {
  574.                                     break label367;
  575.                                  }
  576.                               }
  577.                            }
  578.  
  579.                            while(var33 > 0 && var35 < 4) {
  580.                               int var34 = 8 - var14;
  581.                               var32[var35] = var12[var15];
  582.                               if (var33 >= var34) {
  583.                                  ++var15;
  584.                                  var14 = 0;
  585.                                  --var13;
  586.                               } else {
  587.                                  var14 += var33;
  588.                               }
  589.  
  590.                               var33 -= var34;
  591.                               ++var35;
  592.                               if (var14 == 0) {
  593.                                  if (var12[var15] == 255) {
  594.                                     while(var12[var15 + 1] == 255) {
  595.                                        ++var15;
  596.                                        --var13;
  597.                                     }
  598.  
  599.                                     if (var12[var15 + 1] != 0) {
  600.                                        break label367;
  601.                                     }
  602.                                  } else if (var12[var15] == 0 && var12[var15 - 1] == 255) {
  603.                                     ++var15;
  604.                                     --var13;
  605.                                     if (var12[var15] == 255) {
  606.                                        while(var12[var15 + 1] == 255) {
  607.                                           ++var15;
  608.                                           --var13;
  609.                                        }
  610.  
  611.                                        if (var12[var15 + 1] != 0) {
  612.                                           break label367;
  613.                                        }
  614.                                     }
  615.                                  }
  616.                               }
  617.                            }
  618.  
  619.                            int var47 = ((var32[0] & 255) << 24) + ((var32[1] & 255) << 16) + ((var32[2] & 255) << 8) + (var32[3] & 255);
  620.                            var47 <<= var31;
  621.                            if (var47 > 0) {
  622.                               var47 = 0 - (~var47 >>> 32 - var56);
  623.                            } else {
  624.                               var47 >>>= 32 - var56;
  625.                            }
  626.  
  627.                            var10[var20] = var47;
  628.                            ++var20;
  629.                         }
  630.                      }
  631.                   }
  632.  
  633.                   if (var20 > 64) {
  634.                      break label367;
  635.                   }
  636.  
  637.                   int[] var53 = this.field_5[this.field_6[var26].├Ç];
  638.  
  639.                   for(int var55 = 0; var55 < 64; ++var55) {
  640.                      var10[var55] *= var53[var55];
  641.                      var11[this.field_15[var55]] = var10[var55];
  642.                   }
  643.  
  644.                   this.method_8(var11);
  645.                   this.method_9(var26, var5[var23], this.field_21, this.field_13[var23]);
  646.                   int var10002 = var5[var23]++;
  647.                }
  648.  
  649.                ++var23;
  650.             }
  651.  
  652.             while(true) {
  653.                var23 = var12[var15];
  654.                int var43 = var12[var15 + 1];
  655.                if (var23 == 255 && var43 != 255 && var43 != 0) {
  656.                   if (var43 < 208 || var43 > 215) {
  657.                      this.method_11(-var13);
  658.                      return true;
  659.                   }
  660.  
  661.                   var9[0] = var9[1] = var9[2] = var9[3] = 0;
  662.                   var15 += 2;
  663.                   var14 = 0;
  664.                   var13 -= 2;
  665.                   if (var22) {
  666.                      return true;
  667.                   }
  668.                   break;
  669.                }
  670.  
  671.                if (var13 <= 30 && !var16) {
  672.                   for(int var44 = 0; var44 < var13; ++var44) {
  673.                      var12[var44] = var12[var15 + var44];
  674.                   }
  675.  
  676.                   var15 = 0;
  677.                   int var45;
  678.                   if (this.poolsize - this.field_19 > 100) {
  679.                      var45 = 100;
  680.                   } else {
  681.                      var45 = this.poolsize - this.field_19;
  682.                   }
  683.  
  684.                   for(int var46 = 0; var46 < var45; ++var46) {
  685.                      var12[var13 + var46] = this.method_12();
  686.                   }
  687.  
  688.                   var13 += var45;
  689.                   if (this.field_19 == this.poolsize) {
  690.                      var16 = true;
  691.                   }
  692.                }
  693.  
  694.                ++var15;
  695.                --var13;
  696.                if (var13 <= 0) {
  697.                   return true;
  698.                }
  699.  
  700.                int var10000 = var12[var15];
  701.                var10000 = var12[var15 + 1];
  702.             }
  703.          }
  704.       } else {
  705.          return false;
  706.       }
  707.    }
  708.  
  709.    // $FF: renamed from: ├î (int, int) int
  710.    int method_6(int var1, int var2) {
  711.       return var1 + (1 << var2 - 1) >> var2;
  712.    }
  713.  
  714.    // $FF: renamed from: ├ì (int) int
  715.    int method_7(int var1) {
  716.       if (var1 > 255) {
  717.          var1 = 255;
  718.       } else if (var1 < 0) {
  719.          var1 = 0;
  720.       }
  721.  
  722.       return var1;
  723.    }
  724.  
  725.    // $FF: renamed from: ├Ä (int[]) void
  726.    void method_8(int[] var1) {
  727.       int[] var15 = new int[64];
  728.       int var16 = 0;
  729.       int var17 = 0;
  730.  
  731.       for(int var18 = 8; var18 > 0; --var18) {
  732.          if ((var1[var16 + 8] | var1[var16 + 16] | var1[var16 + 24] | var1[var16 + 32] | var1[var16 + 40] | var1[var16 + 48] | var1[var16 + 56]) == 0) {
  733.             int var19 = var1[var16 + 0] << 2;
  734.             var15[var17 + 0] = var19;
  735.             var15[var17 + 8] = var19;
  736.             var15[var17 + 16] = var19;
  737.             var15[var17 + 24] = var19;
  738.             var15[var17 + 32] = var19;
  739.             var15[var17 + 40] = var19;
  740.             var15[var17 + 48] = var19;
  741.             var15[var17 + 56] = var19;
  742.             ++var16;
  743.             ++var17;
  744.          } else {
  745.             int var11 = var1[var16 + 16];
  746.             int var12 = var1[var16 + 48];
  747.             int var10 = (var11 + var12) * 4433;
  748.             int var4 = var10 + var12 * -15137;
  749.             int var5 = var10 + var11 * 6270;
  750.             var11 = var1[var16 + 0];
  751.             var12 = var1[var16 + 32];
  752.             int var2 = var11 + var12 << 13;
  753.             int var3 = var11 - var12 << 13;
  754.             int var6 = var2 + var5;
  755.             int var9 = var2 - var5;
  756.             int var7 = var3 + var4;
  757.             int var8 = var3 - var4;
  758.             var2 = var1[var16 + 56];
  759.             var3 = var1[var16 + 40];
  760.             var4 = var1[var16 + 24];
  761.             var5 = var1[var16 + 8];
  762.             var10 = var2 + var5;
  763.             var11 = var3 + var4;
  764.             var12 = var2 + var4;
  765.             int var13 = var3 + var5;
  766.             int var14 = (var12 + var13) * 9633;
  767.             var2 *= 2446;
  768.             var3 *= 16819;
  769.             var4 *= 25172;
  770.             var5 *= 12299;
  771.             var10 *= -7373;
  772.             var11 *= -20995;
  773.             var12 *= -16069;
  774.             var13 *= -3196;
  775.             var12 += var14;
  776.             var13 += var14;
  777.             var2 += var10 + var12;
  778.             var3 += var11 + var13;
  779.             var4 += var11 + var12;
  780.             var5 += var10 + var13;
  781.             var15[var17 + 0] = this.method_6(var6 + var5, 11);
  782.             var15[var17 + 56] = this.method_6(var6 - var5, 11);
  783.             var15[var17 + 8] = this.method_6(var7 + var4, 11);
  784.             var15[var17 + 48] = this.method_6(var7 - var4, 11);
  785.             var15[var17 + 16] = this.method_6(var8 + var3, 11);
  786.             var15[var17 + 40] = this.method_6(var8 - var3, 11);
  787.             var15[var17 + 24] = this.method_6(var9 + var2, 11);
  788.             var15[var17 + 32] = this.method_6(var9 - var2, 11);
  789.             ++var16;
  790.             ++var17;
  791.          }
  792.       }
  793.  
  794.       var17 = 0;
  795.       int var80 = 0;
  796.       int var20 = 0;
  797.  
  798.       for(int var21 = 0; var21 < 8; ++var21) {
  799.          var20 = var21 * 8;
  800.          int var62 = var15[var17 + 2];
  801.          int var69 = var15[var17 + 6];
  802.          int var56 = (var62 + var69) * 4433;
  803.          int var39 = var56 + var69 * -15137;
  804.          int var46 = var56 + var62 * 6270;
  805.          int var25 = var15[var17 + 0] + var15[var17 + 4] << 13;
  806.          int var32 = var15[var17 + 0] - var15[var17 + 4] << 13;
  807.          int var50 = var25 + var46;
  808.          int var53 = var25 - var46;
  809.          int var51 = var32 + var39;
  810.          int var52 = var32 - var39;
  811.          var25 = var15[var17 + 7];
  812.          var32 = var15[var17 + 5];
  813.          var39 = var15[var17 + 3];
  814.          var46 = var15[var17 + 1];
  815.          var56 = var25 + var46;
  816.          var62 = var32 + var39;
  817.          var69 = var25 + var39;
  818.          int var75 = var32 + var46;
  819.          int var78 = (var69 + var75) * 9633;
  820.          var25 *= 2446;
  821.          var32 *= 16819;
  822.          var39 *= 25172;
  823.          var46 *= 12299;
  824.          var56 *= -7373;
  825.          var62 *= -20995;
  826.          var69 *= -16069;
  827.          var75 *= -3196;
  828.          var69 += var78;
  829.          var75 += var78;
  830.          var25 += var56 + var69;
  831.          var32 += var62 + var75;
  832.          var39 += var62 + var69;
  833.          var46 += var56 + var75;
  834.          var80 = this.method_6(var50 + var46, 18) + 128;
  835.          this.field_21[var20 + 0] = this.method_7(var80);
  836.          var80 = this.method_6(var50 - var46, 18) + 128;
  837.          this.field_21[var20 + 7] = this.method_7(var80);
  838.          var80 = this.method_6(var51 + var39, 18) + 128;
  839.          this.field_21[var20 + 1] = this.method_7(var80);
  840.          var80 = this.method_6(var51 - var39, 18) + 128;
  841.          this.field_21[var20 + 6] = this.method_7(var80);
  842.          var80 = this.method_6(var52 + var32, 18) + 128;
  843.          this.field_21[var20 + 2] = this.method_7(var80);
  844.          var80 = this.method_6(var52 - var32, 18) + 128;
  845.          this.field_21[var20 + 5] = this.method_7(var80);
  846.          var80 = this.method_6(var53 + var25, 18) + 128;
  847.          this.field_21[var20 + 3] = this.method_7(var80);
  848.          var80 = this.method_6(var53 - var25, 18) + 128;
  849.          this.field_21[var20 + 4] = this.method_7(var80);
  850.          var17 += 8;
  851.       }
  852.  
  853.    }
  854.  
  855.    // $FF: renamed from: ├Å (int, int, int[], byte[]) void
  856.    void method_9(int var1, int var2, int[] var3, byte[] var4) {
  857.       int var11 = var2 / (this.field_6[var1].h * this.field_6[var1].v);
  858.       var2 %= this.field_6[var1].h * this.field_6[var1].v;
  859.       int var7 = var11 % this.field_11;
  860.       int var8 = var11 / this.field_11;
  861.       int var9 = var2 % this.field_6[var1].h;
  862.       int var10 = var2 / this.field_6[var1].h;
  863.       if (var7 < this.field_11 && var8 < this.field_12) {
  864.          var7 *= this.field_9 * 8;
  865.          var8 *= this.field_10 * 8;
  866.          int var12 = this.field_9 / this.field_6[var1].h;
  867.          int var13 = this.field_10 / this.field_6[var1].v;
  868.          var9 *= var12 * 8;
  869.          var10 *= var13 * 8;
  870.          int var5 = var7 + var9;
  871.          int var6 = var8 + var10;
  872.          int var18 = this.field_2 * var6 + var5;
  873.          int var19 = 0;
  874.          int var20 = 0;
  875.  
  876.          for(int var16 = 0; var16 < var13; ++var16) {
  877.             for(int var17 = 0; var17 < var12; ++var17) {
  878.                var19 = 0;
  879.  
  880.                for(int var14 = 0; var14 < 8; ++var14) {
  881.                   var20 = var18 + (var16 + var14 * var13) * this.field_2 + var17;
  882.  
  883.                   for(int var15 = 0; var15 < 8; ++var15) {
  884.                      var4[var20] = (byte)var3[var19];
  885.                      ++var19;
  886.                      var20 += var12;
  887.                   }
  888.                }
  889.             }
  890.          }
  891.  
  892.       }
  893.    }
  894.  
  895.    // $FF: renamed from: ├É () void
  896.    void method_10() {
  897.       int var8 = 0;
  898.       this.field_16 = Image.createImage(this.field_0, this.field_1);
  899.       Graphics var9 = this.field_16.getGraphics();
  900.       if (this.field_4 == 3 && !this.field_17) {
  901.          for(int var16 = 0; var16 < this.field_3; ++var16) {
  902.             if (var16 >= this.field_1) {
  903.                var8 += this.field_2;
  904.             } else {
  905.                for(int var17 = 0; var17 < this.field_2; ++var17) {
  906.                   if (var17 >= this.field_0) {
  907.                      ++var8;
  908.                   } else {
  909.                      int var12 = this.field_13[0][var8] & 255;
  910.                      if (this.field_18 != 0) {
  911.                         var12 += var12 * this.field_18 / 100;
  912.                         if (var12 > 255) {
  913.                            var12 = 255;
  914.                         } else if (var12 < 0) {
  915.                            var12 = 0;
  916.                         }
  917.                      }
  918.  
  919.                      int var2 = this.field_13[1][var8] & 255;
  920.                      var2 -= 128;
  921.                      int var3 = this.field_13[2][var8] & 255;
  922.                      var3 -= 128;
  923.                      int var4 = var12 + 1402 * var3 / 1000;
  924.                      if (var4 > 255) {
  925.                         var4 = 255;
  926.                      } else if (var4 < 0) {
  927.                         var4 = 0;
  928.                      }
  929.  
  930.                      int var5 = var12 - ('ΦÖ«' * var2 + 71414 * var3) / 100000;
  931.                      if (var5 > 255) {
  932.                         var5 = 255;
  933.                      } else if (var5 < 0) {
  934.                         var5 = 0;
  935.                      }
  936.  
  937.                      int var6 = var12 + 1772 * var2 / 1000;
  938.                      if (var6 > 255) {
  939.                         var6 = 255;
  940.                      } else if (var6 < 0) {
  941.                         var6 = 0;
  942.                      }
  943.  
  944.                      int var15 = (var4 << 16) + (var5 << 8) + var6;
  945.                      var9.setColor(var15);
  946.                      var9.drawLine(var17, var16, var17, var16);
  947.                      ++var8;
  948.                   }
  949.                }
  950.             }
  951.          }
  952.       } else {
  953.          for(int var10 = 0; var10 < this.field_3; ++var10) {
  954.             if (var10 >= this.field_1) {
  955.                var8 += this.field_2;
  956.             } else {
  957.                for(int var11 = 0; var11 < this.field_2; ++var11) {
  958.                   if (var11 >= this.field_0) {
  959.                      ++var8;
  960.                   } else {
  961.                      int var1 = this.field_13[0][var8] & 255;
  962.                      if (this.field_18 != 0) {
  963.                         var1 += var1 * this.field_18 / 100;
  964.                         if (var1 > 255) {
  965.                            var1 = 255;
  966.                         } else if (var1 < 0) {
  967.                            var1 = 0;
  968.                         }
  969.                      }
  970.  
  971.                      int var7 = (var1 << 16) + (var1 << 8) + var1;
  972.                      var9.setColor(var7);
  973.                      var9.drawLine(var11, var10, var11, var10);
  974.                      ++var8;
  975.                   }
  976.                }
  977.             }
  978.          }
  979.       }
  980.  
  981.    }
  982.  
  983.    // $FF: renamed from: ├æ (int) void
  984.    void method_11(int var1) {
  985.       if (this.field_19 + var1 >= this.poolsize) {
  986.          this.field_19 = this.poolsize;
  987.       } else if (this.field_19 + var1 < 0) {
  988.          this.field_19 = 0;
  989.       } else {
  990.          this.field_19 += var1;
  991.       }
  992.  
  993.    }
  994.  
  995.    // $FF: renamed from: ├Æ () int
  996.    int method_12() {
  997.       if (this.field_19 == this.poolsize) {
  998.          return 0;
  999.       } else {
  1000.          int var1 = this.field_20[this.field_19];
  1001.          if (var1 < 0) {
  1002.             var1 += 256;
  1003.          }
  1004.  
  1005.          if (this.field_19 + 1 <= this.poolsize) {
  1006.             ++this.field_19;
  1007.          }
  1008.  
  1009.          return var1;
  1010.       }
  1011.    }
  1012.  
  1013.    // $FF: renamed from: ├ô () int
  1014.    int method_13() {
  1015.       return this.method_12() << 8 ^ this.method_12();
  1016.    }
  1017.  
  1018.    void clear() {
  1019.    }
  1020. }
  1021.